﻿using EntGuayasSLA.BL;
using EntGuayasSLA.BL.Licenciamiento;
using EntGuayasSLA.BL.Listas;
using Ext.Net;
using System;
using System.Collections.Generic;
using System.Configuration;
using System.IO;
using System.Linq;
using System.Text;
using System.Web;
using System.Xml.Linq;

namespace EGuayas.Web.Expedientes
{
    public class ExpedienteIU : pgBase
    {
        /// <summary>
        /// Id de expediente temporal creado
        /// </summary>
        protected string CodeFaseInicial
        {
            get
            {
                if (Session[SessionPage.PageGestionExpLic + "_CodeFaseInicial"] == null)
                {
                    Session[SessionPage.PageGestionExpLic + "_CodeFaseInicial"] = "";
                }
                return (Session[SessionPage.PageGestionExpLic + "_CodeFaseInicial"].ToString());
            }
            set
            {
                Session[SessionPage.PageGestionExpLic + "_CodeFaseInicial"] = value;
            }
        }
        /// <summary>
        /// Id de expediente temporal creado
        /// </summary>
        protected string ExpedienteIdTmp
        {
            get
            {
                if (Session[SessionPage.PageGestionExpLic + "_ExpedienteIdTmp"] == null)
                {
                    Session[SessionPage.PageGestionExpLic + "_ExpedienteIdTmp"] = "";
                }
                return (Session[SessionPage.PageGestionExpLic + "_ExpedienteIdTmp"].ToString());
            }
            set
            {
                Session[SessionPage.PageGestionExpLic + "_ExpedienteIdTmp"] = value;
            }
        }
        protected string ExpedienteEstadoTmp
        {
            get
            {
                if (Session[SessionPage.PageGestionExpLic + "_ExpedienteEstadoTmp"] == null)
                {
                    Session[SessionPage.PageGestionExpLic + "_ExpedienteEstadoTmp"] = "";
                }
                return (Session[SessionPage.PageGestionExpLic + "_ExpedienteEstadoTmp"].ToString());
            }
            set
            {
                Session[SessionPage.PageGestionExpLic + "_ExpedienteEstadoTmp"] = value;
            }
        }
        protected string ExpedienteLicEstadoTmp
        {
            get
            {
                if (Session[SessionPage.PageGestionExpLic + "_ExpedienteEstadoLicTmp"] == null)
                {
                    Session[SessionPage.PageGestionExpLic + "_ExpedienteEstadoLicTmp"] = "";
                }
                return (Session[SessionPage.PageGestionExpLic + "_ExpedienteEstadoLicTmp"].ToString());
            }
            set
            {
                Session[SessionPage.PageGestionExpLic + "_ExpedienteEstadoLicTmp"] = value;
            }
        }
        /// <summary>
        ///Obtener los datos de promotor y setearlos en obj Dinamic
        /// </summary>
        /// <param name="idPromotor"></param>
        /// <returns></returns>
        public Dynamic GetDataPromotor(Guid idPromotor)
        {
            Dynamic valReturn = new Dynamic();
            try
            {
                string txtRepresentLegal = "";
                Promotores objPromotor = Promotores.GetEditableRoot(idPromotor);


                if (objPromotor.Identificacion != "")
                {
                    txtRepresentLegal = objPromotor.RepresentanteLegal;
                    if (objPromotor.Delegado != "")
                    {
                        Persona objDelegado = Persona.GetEditableRoot(Guid.Parse(objPromotor.Delegado));
                        txtRepresentLegal = objDelegado.Nombre + " " + objDelegado.Apellido;
                    }

                    Parroquia objParroquia = Parroquia.GetEditableRoot(Guid.Parse(objPromotor.ParroquiaId));

                    valReturn.Add("IdPromotor", objPromotor.Id.ToString());
                    valReturn.Add("NombresP", objPromotor.Nombre + " " + objPromotor.Apellido);
                    valReturn.Add("DireccionP", objPromotor.Direccion);
                    valReturn.Add("SectorP", objParroquia.Nombre);
                    valReturn.Add("TelefonoP", objPromotor.Telefono);
                    valReturn.Add("CiudadP", objParroquia.NombreCanton);
                    valReturn.Add("FaxP", objPromotor.Fax);
                    valReturn.Add("ProvinciaP", objParroquia.NombreProvincia);
                    valReturn.Add("CorreoP", objPromotor.Email);
                    valReturn.Add("RepresentanteP", txtRepresentLegal);

                }
            }
            catch (Exception ex)
            {
                RegistrarLog(ex);
            }

            return valReturn;
        }
        int SaveItemOpciones(Dictionary<string, string> dataItem, CategoriaInformacionInfo pregunta)
        {
            try
            {
                int existPreg = 0;
                foreach (var opcion in pregunta.Opciones)
                {

                    if (dataItem.Keys.Contains(opcion.Codigo))
                    {
                        string idCodigoOtro = "txt_" + opcion.Codigo;
                        string valorOtro = (dataItem.Keys.Contains(idCodigoOtro)) ? dataItem[idCodigoOtro] : "";
                        CategoriaExpediente objCat01 = CategoriaExpediente.NewEditableRoot();
                        objCat01.Id = System.Guid.NewGuid();
                        objCat01.Codigo = opcion.Codigo;
                        objCat01.ExpedienteId = ExpedienteIdTmp;
                        objCat01.Otro = valorOtro;
                        objCat01.Save();
                        existPreg = 1;
                    }// if (dataItem.Keys.Contains(opcion.Codigo))

                }// foreach 
                return (existPreg);
            }
            catch (Exception ex)
            {
                RegistrarLog(ex);
                return (0);
            }
        }
        
        protected void OnInforDocAdded(object sender, ComponentAddedEventArgs e)
        {
            try
            {
                Ext.Net.Panel panel = (Ext.Net.Panel)e.Control;
                SetCustomConfigWucPage(panel, SessionPage.PageGestionExpLic);
                SetCustomConfigWucLicAll(panel, SessionPage.PageGestionExpLic, Constantes.LCategorizacion);
            }
            catch (Exception ex)
            {
                RegistrarLog(ex);
            }
        }
        protected void UpdateExpendiente(Dictionary<string, string> dataItem)
        {
            try
            {
                DateTime saveNow = DateTime.Now;
                Expediente expObjUpdate = Expediente.GetEditableRoot(Guid.Parse(ExpedienteIdTmp));
                expObjUpdate.ParroquiaId = dataItem["Parroquia"];
                expObjUpdate.PromotorId = dataItem["IdPromotor"];
                expObjUpdate.Nombre = dataItem["Nombre"];
                expObjUpdate.Descripcion = dataItem["Descripcion"];
                expObjUpdate.Comunidad = dataItem["Comunidad"];
                //expObjUpdate.Categoria = "";
                expObjUpdate.Tipo = dataItem["Tipo"];
                expObjUpdate.Direccion = dataItem["Direccion"];
                expObjUpdate.FechaCreacion = DateTime.Parse(dataItem["Fecha"]);
                expObjUpdate.NumeroCategoria = 1;
                expObjUpdate.Save();
            }
            catch (Exception ex)
            {
                RegistrarLog(ex);
            }
        }
        /// <summary>
        /// Crear nuevo expediente con fase categorizacion o tdr
        /// </summary>
        /// <param name="dataItem"></param>
        public void NuevoExpediente(Dictionary<string, string> dataItem, string codFaseInicial)
        {
            Expediente objExp = Expediente.NewEditableRoot();
            //Obtener secuencia
            DateTime saveNow = DateTime.Now;
            Secuencia secuExp = Secuencia.GetEditableRoot(saveNow.Year, Constantes.Licenciamiento, Valores.Codigo_CHAR_Si);
            //Rellenar un entero con ceros iniciales hasta una longitud concreta
            int numeroSecuencia = secuExp.Numero;
            int decimalLength = 4;
            //Crear expediente
            objExp.Id = System.Guid.NewGuid();
            objExp.ParroquiaId = dataItem["Parroquia"];
            objExp.PromotorId = dataItem["IdPromotor"];
            objExp.Nombre = dataItem["Nombre"];
            objExp.Tipo = dataItem["Tipo"];
            objExp.Descripcion = dataItem["Descripcion"];
            objExp.Comunidad = dataItem["Comunidad"];
            objExp.Categoria = dataItem["Categoria"];
            //GPG-13-0001-L
            objExp.Codigo = Valores.CodigoInicialExpediente_A + saveNow.Year.ToString().Substring(2) + "-" + numeroSecuencia.ToString("D" + decimalLength.ToString()) + Valores.CodigoInicialExpediente_B;
            objExp.Direccion = dataItem["Direccion"];
            objExp.FechaCreacion = DateTime.Parse(dataItem["Fecha"]);
            objExp.NumeroCategoria = 1;
            objExp.Estado = "I";//INACTIVO
            //
            objExp.Save();
            //Setea valor de session
            ExpedienteIdTmp = objExp.Id.ToString();

            //Aqui se creara el expediente de licenciamiento  y la fase de categorizacion
            ExpedienteLicenciamiento objExpLic = ExpedienteLicenciamiento.NewEditableRoot();
            objExpLic.Id            = System.Guid.NewGuid();
            objExpLic.ExpedienteId  = ExpedienteIdTmp;
            objExpLic.Estado        = Valores.Codigo_Estado_Exp_Lic_Inicial;
            objExpLic.FechaCreacion = DateTime.Now;
            objExpLic.Codigo        = objExp.Codigo;

            //Aqui se establece la categoria del expediente en base a la seleccion de la categoria inicial
            objExpLic.Categoria = ObtenerCategoria(objExp.Categoria);
         
            objExpLic.Save();
            //Aqui obtengo el listado de fase de licenciamiento y obtengo la fase de categorizacion
            //Se comenta porque ya viene dado desde donde se llama a esta función
            /*string codFaseInicial = Constantes.LCategorizacion;
            if (dataItem["Categoria"] == Constantes.FaseConfigTdr)
            {
                codFaseInicial = Constantes.LTDR;
            }*/
            //                  
            var itemsReturn = FaseLicenciamientoLista.GetFaseLicenciamientoLista();
            var faseInicial = itemsReturn.FirstOrDefault(f => f.CodigoFase == codFaseInicial);
            //Aqui se creara la fase de categorización
            FaseLicenciamiento objFaseLic = FaseLicenciamiento.NewEditableRoot();
            objFaseLic.Id = System.Guid.NewGuid();
            objFaseLic.ExpedienteLicId = objExpLic.Id.ToString();
            objFaseLic.FaseId = faseInicial.FaseId.ToString();
            objFaseLic.FechaInicial = DateTime.Now;
            objFaseLic.EstadoFase = Valores.Codigo_Estado_Fase_Creado;
            objFaseLic.Save();

            //Documentos de promotor
            Guid idPromotor = Guid.Parse(objExp.PromotorId);
            Promotores objPromotor = Promotores.GetEditableRoot(idPromotor);
            int nCount = 0;
            ArchivoLista listaArchivos = ArchivoLista.GetArchivoLista(objPromotor.PersonaId, out nCount);
            foreach (ArchivoInfo info in listaArchivos)
            {
                PersonaFaseLicArchivo objPerFaseLic = PersonaFaseLicArchivo.NewEditableRoot();
                objPerFaseLic.Id = objFaseLic.Id;
                objPerFaseLic.ArchivoId = info.ArchivoId.ToString();
                objPerFaseLic.PersonaId = objPromotor.PersonaId;
                objPerFaseLic.ExpedienteId = objExp.Id.ToString();
                objPerFaseLic.Fecha = DateTime.Now;
                objPerFaseLic.Save();

            }
            //Setaer Fase para agregar documentos
            Session[SessionPage.PageGestionExpLic + Constantes.Expediente] = objExp.Id.ToString();
            Session[SessionPage.PageGestionExpLic + codFaseInicial] = objFaseLic.Id.ToString();
            Session[SessionPage.PageGestionExpLic + "FASE_ID_" + codFaseInicial] = faseInicial.FaseId.ToString();
           

        }

        private string ObtenerCategoria(string p)
        {
            var cat="";
            switch (p)
            {
                case "c1":
                case "c2":
                    cat = "Cat3";
                    break;
                case "c3":
                    cat = "Cat2";
                    break;
            }
            return cat;
        }
        /// <summary>
        /// Obtine los datos de validaciones ficha, y crea tab adicional con sumario de dicha informacion
        /// </summary>
        /// <param name="respuestas"></param>
        /// <param name="codeIdTxt"></param>
        /// <param name="tb"></param>
        /// <returns></returns>
        public string SetValidacionesFicha(Dynamic respuestas, string codeIdTxt, TabPanel tb)
        {
            int iCountEvilOK = 0;
            ValidacionOpcionesLista opcLista = ValidacionOpcionesLista.GetValidacionOpciones(ExpedienteIdTmp);
            foreach (var opcFicha in opcLista)
            {

                codeIdTxt = string.Format("txtArea_{0}", opcFicha.Codigo);
                respuestas.Add(codeIdTxt, opcFicha.Comentario);
                codeIdTxt = string.Format("btn_txtArea_{0}", opcFicha.Codigo);
                SplitButton btn = (SplitButton)this.FindControl(codeIdTxt);
                btn.Text = (opcFicha.Valido == Valores.Codigo_CHAR_Si) ? "Si" : "No";
                if (opcFicha.Comentario != "")
                {
                    iCountEvilOK = iCountEvilOK + 1;
                }
            }
            if (GetSessionUsuario.UsuarioRolCodigo == Valores.Codigo_Rol_Promotor)
            {
                if (iCountEvilOK != 0)
                {

                    StringBuilder strigHtml = new StringBuilder();
                    strigHtml.Append("<ul>");
                    foreach (var opcFicha in opcLista)
                    {
                        if (opcFicha.Comentario != "")
                        {
                            strigHtml.Append("<li type='square'>");
                            strigHtml.Append("<b>" + opcFicha.TextoPregunta + "</b><br>");
                            strigHtml.Append(opcFicha.Comentario);
                            strigHtml.Append("</li>");
                        }
                    }
                    strigHtml.Append("</ul>");
                    FormPanel fmpPanelBug = new FormPanel();
                    fmpPanelBug.Title = "Correcciones Expediente";
                    fmpPanelBug.Icon = Icon.ApplicationError;
                    fmpPanelBug.Html = strigHtml.ToString();
                    fmpPanelBug.AutoScroll = true;
                    tb.Add(fmpPanelBug);
                    tb.SetActiveTab(tb.Items.Count-1);
                }
            }

            return codeIdTxt;
        }
        public Dynamic GetPreguntasForm(string idExpediente, out Parroquia objParrExp, out List<string> txtIdsArray, out string codeIdTxt)
        {
            Dynamic respuestas = new Dynamic();
            //Aqui obtengo el listado de fase de licenciamiento y obtengo la fase de categorizacion
            string CodigoFase="";
            //Determinar segun la categoria codigo de fase inicial
            Expediente expObjUpdate = Expediente.GetEditableRoot(Guid.Parse(ExpedienteIdTmp));
            /*if (expObjUpdate.Categoria == Constantes.FaseConfigTdr)
            {
                CodigoFase = Constantes.LTDR;
               
            }
            else
            {
                CodigoFase = Constantes.LCategorizacion;

            }*/

            Session[SessionPage.PageGestionExpLic + Constantes.Expediente] = idExpediente;
            if (expObjUpdate.Categoria != "")
            {
                CodigoFase = ObtenerCodigoIncial(expObjUpdate.Categoria);
                //
                var itemsReturn = FaseLicenciamientoLista.GetFaseLicenciamientoLista();
                var faseCat = itemsReturn.FirstOrDefault(f => f.CodigoFase == CodigoFase);
                var itemsReturnLic = FaseLicenciamientoLista.GetFaseLicenciamientoLista(Guid.Parse(idExpediente));
                var objFaseLic = itemsReturnLic.FirstOrDefault(f => f.CodigoFase == CodigoFase);
                //Setaer Fase para agregar documentos              

                Session[SessionPage.PageGestionExpLic + CodigoFase] = objFaseLic.Id.ToString();
                Session[SessionPage.PageGestionExpLic + "FASE_ID_" + CodigoFase] = faseCat.FaseId.ToString();
                Session[SessionPage.PageGestionExpLic + "_estadoFase" + CodigoFase] = objFaseLic.EstadoFase;
            }

            //
            SetSessionPage setSession = new SetSessionPage(SessionPage.PageGestionExpLic,
                                                           Valores.PageEvento_Modificar);
          
           
            //Setear estado de expediente
            ExpedienteEstadoTmp = expObjUpdate.Estado;
            //Obtener valor de parroquia
            objParrExp = Parroquia.GetEditableRoot(Guid.Parse(expObjUpdate.ParroquiaId));
            Guid idPromotor = Guid.Parse(expObjUpdate.PromotorId);
            respuestas = GetDataPromotor(idPromotor);
            respuestas.Add("CodigoFaseNow", CodigoFase);
            respuestas.Add("Nombre", expObjUpdate.Nombre);
            respuestas.Add("Tipo", expObjUpdate.Tipo);
            respuestas.Add("Fecha", expObjUpdate.FechaCreacion.ToShortDateString());
            respuestas.Add("Categoria", expObjUpdate.Categoria);

            /*
            if (expObjUpdate.Codigo.Length != 0)
            {
                try
                {
                    //GPG-13-0001-L  //1234567891023
                    int lengthSubCodigo =13;
                    // ID="txtCodigo" FieldLabel="Código:  GPG-13-0001-L"
                    this.txtCodigo.FieldLabel = "Código:  "+expObjUpdate.Codigo.Substring(0, lengthSubCodigo);
                    respuestas.Add("Codigo", expObjUpdate.Codigo.Substring(lengthSubCodigo, 4));
                    respuestas.Add("CodigoAdd", expObjUpdate.Codigo.Substring(lengthSubCodigo + 4));
                }
                catch
                { }
            }
            else
            {
                respuestas.Add("Codigo", "");
                respuestas.Add("CodigoAdd", "");
            }
            */
            respuestas.Add("Descripcion", expObjUpdate.Descripcion);
            respuestas.Add("Provincia", objParrExp.ProvinciaId);
            respuestas.Add("Canton", objParrExp.CantonId);
            respuestas.Add("Parroquia", expObjUpdate.ParroquiaId);
            respuestas.Add("Comunidad", expObjUpdate.Comunidad);
            respuestas.Add("Direccion", expObjUpdate.Direccion);

            txtIdsArray = new List<string>();
            codeIdTxt = "";

            foreach (var itemResult_03 in expObjUpdate.Respuestas)
            {
                if (itemResult_03.Tipo == Constantes.UNICA)
                {
                    /*
                          -		[92]	{[EVAAGUALLUVIA, EALALCANPLUVIAL]}	System.Collections.Generic.KeyValuePair<string,string>
                                   Key	"EVAAGUALLUVIA"	string
                                   Value	"EALALCANPLUVIAL"	string
                           +		Non-Public members	
                             
                     */
                    respuestas.Add(itemResult_03.CodigoCategoria, itemResult_03.Codigo);
                    if (itemResult_03.Otro != "")
                    {
                        //TextField ID=\"txt_{1}, opcion.Codigo
                        /*
                           -		[95]	{[txt_DSOTRO, ]}	System.Collections.Generic.KeyValuePair<string,string>
                                    Key	"txt_DSOTRO"	string
                                    Value	""	string
                            +		Non-Public members
                        */
                        codeIdTxt = string.Format("txt_{0}", itemResult_03.Codigo);
                        respuestas.Add(codeIdTxt, itemResult_03.Otro);
                        txtIdsArray.Add(codeIdTxt);
                    } // if [itemResult_03.Otro != ""]

                }
                else
                {
                    /*
                              [22]	{[MINISTERIO, App.ch_MINISTERIO]}	System.Collections.Generic.KeyValuePair<string,string>
                                   Key	"MINISTERIO"	string
                                   Value	"App.ch_MINISTERIO"	string
                                   Non-Public members	
                    */
                    respuestas.Add(itemResult_03.Codigo, string.Format("App.ch_{0}", itemResult_03.Codigo));
                    if (itemResult_03.Otro != "")
                    {
                        //TextField ID=\"txt_{1}, opcion.Codigo
                        /*
                            [23]	{[txt_MINISTERIO, Loja]}	System.Collections.Generic.KeyValuePair<string,string>
                            Key	"txt_MINISTERIO"	string
                            Value	"Loja"	string
                        */
                        codeIdTxt = string.Format("txt_{0}", itemResult_03.Codigo);
                        respuestas.Add(codeIdTxt, itemResult_03.Otro);
                        txtIdsArray.Add(codeIdTxt);
                    } // if [itemResult_03.Otro != ""]

                }
                string numFieldId = string.Format("nuf_{0}", itemResult_03.CodigoCategoria);
                respuestas.Add(numFieldId, "1");
            }

           

            return (respuestas);
        }

            
        #region Generar Formularios
        /// <summary>
        /// Evento al realizar click "Grabar" expediente
        /// </summary>
        /// <param name="e"></param>
        /// <returns></returns>
        public string SaveFicha(DirectEventArgs e, string oper, Boolean estadodoNoFinalizado)
        {
            string codFaseInicial="";
            Boolean ifCompleto = true;
            string gridJson = e.ExtraParams["prmValues"];        
            var dataItem = JSON.Deserialize<Dictionary<string, string>>(gridJson);
            codFaseInicial = ObtenerCodigoIncial(dataItem["Categoria"]);
            
            switch (dataItem["Categoria"])
            { 
            
                case "c1":
                case "c2":
                case "c3":
                            if (ExpedienteIdTmp == "")
                            {
                                NuevoExpediente(dataItem, codFaseInicial);
                            }
                            else
                            {
                                UpdateExpendiente(dataItem);
                            }
                            if (oper == "NUEVO")
                            {
                                ifCompleto = UpdateEstadoCreado(ifCompleto);
                                UpdateEstadoCategorizacionOrTdrOrBF(codFaseInicial);
                            }
                            break; 
                default:
                            if (ExpedienteIdTmp == "")
                            {
                                NuevoExpediente(dataItem, codFaseInicial);
                            }
                            else
                            {
                                UpdateExpendiente(dataItem);
                            }
                            var preguntas = CategoriaInformacionLista.GetCategoriaInformacionLista();
                            Expediente.DeleteAllPreguntas(ExpedienteIdTmp);
                            int valTotalCountPreg = 0;
                            foreach (var pregunta in preguntas)
                            {

                                if (pregunta.Tipo == Constantes.UNICA)
                                {
                                    //Opciones Unicas
                                    if (dataItem.Keys.Contains(pregunta.Codigo))
                                    {
                                        string idCodigoOtro = "txt_" + dataItem[pregunta.Codigo];
                                        string valorOtro = (dataItem.Keys.Contains(idCodigoOtro)) ? dataItem[idCodigoOtro] : "";
                                        CategoriaExpediente objCat01 = CategoriaExpediente.NewEditableRoot();
                                        objCat01.Id = System.Guid.NewGuid();
                                        objCat01.Codigo = dataItem[pregunta.Codigo];
                                        objCat01.ExpedienteId = ExpedienteIdTmp;
                                        objCat01.Otro = valorOtro;
                                        objCat01.Save();
                                        valTotalCountPreg = valTotalCountPreg + 1;
                                    }
                                }
                                else
                                {
                                    valTotalCountPreg = valTotalCountPreg + SaveItemOpciones(dataItem, pregunta);

                                }

                            }
                            //Grabar validacion de ficha de preguntas
                            if (valTotalCountPreg != 0)
                            {
                                Boolean pregInvalid = false;
                                foreach (var pregunta in preguntas)
                                {
                                    ValidacionFicha fichaValid = ValidacionFicha.GetEditableRoot(ExpedienteIdTmp, pregunta.Id.ToString());
                                    if (fichaValid.Expediente == "")
                                    {
                                        fichaValid = ValidacionFicha.NewEditableRoot();
                                        fichaValid.Id = System.Guid.NewGuid();
                                        fichaValid.Expediente = ExpedienteIdTmp;
                                        CategoriaExpediente objCatExp = CategoriaExpediente.GetEditableRoot(pregunta.Id.ToString(), ExpedienteIdTmp);
                                        if (objCatExp.CategoriaId != "")
                                        {
                                            fichaValid.CategoriaId = objCatExp.Id.ToString();
                                            pregInvalid = false;
                                        }
                                        else
                                        {
                                            pregInvalid = true;
                                        }

                                    }
                                    fichaValid.Comentario = (dataItem.Keys.Contains("txtArea_" + pregunta.Codigo)) ? dataItem["txtArea_" + pregunta.Codigo] : "";
                                    fichaValid.Valido = (dataItem["ficha_" + pregunta.Codigo] == "No") ? Valores.Codigo_CHAR_No : Valores.Codigo_CHAR_Si;
                                    if (pregInvalid == false)
                                    {
                                        fichaValid.Save();
                                    }

                                }
                            }
                            if (oper == "NUEVO")
                            {
                                if (estadodoNoFinalizado == false)
                                {
                                    ifCompleto = UpdateEstadoCreado(ifCompleto);
                                    UpdateEstadoCategorizacionOrTdrOrBF(codFaseInicial);
                                }
                               
                            }
                            break;
            }

           
            return codFaseInicial;
        }

        public static string ObtenerCodigoIncial(string categoria)
        {
            string codFaseInicial;
            switch (categoria)
            {
                case Constantes.FaseConfigTdr:
                    codFaseInicial = Constantes.LTDR;
                    break;
                case Constantes.FaseConfigBF1:
                    codFaseInicial = Constantes.LBorradorFicha;
                    break;
                case Constantes.FaseConfigBF2:
                    codFaseInicial = Constantes.LBorradorFicha;
                    break;
                default:
                    codFaseInicial = Constantes.LCategorizacion;
                    break;
            }
            return codFaseInicial;
        }

        /// <summary>
        /// Finalizar creacion de expediente
        /// </summary>
        private void UpdateEstadoCategorizacionOrTdrOrBF(string codFaseInicial)
        {
            FaseLicenciamientoLista itemsSelect = FaseLicenciamientoLista.GetFaseLicenciamientoLista(Guid.Parse(ExpedienteIdTmp));
            //Actualizar estado actual
            //FaseInfo faseFirst = itemsSelect.FirstOrDefault(r => r.EstadoFase == Valores.Codigo_Estado_Fase_Creado);
           // string  = Constantes.LCategorizacion;
           // if (sClasificacion == Constantes.FaseConfigTdr)
           // {
           //     codFaseInicial = Constantes.LTDR;
           // }
            FaseLicenciamientoInfo faseFirst = itemsSelect.FirstOrDefault(r => r.CodigoFase == codFaseInicial);//Cambiar para que consulte por codigo de fase de categorizacion
            if (faseFirst != null)
            {
                
                var faseLic = FaseLicenciamiento.GetEditableRoot(faseFirst.Id);
                //Unicamente si el estado actual es creado se cambia a inicial
                if (faseLic.EstadoFase == Valores.Codigo_Estado_Fase_Creado)
                {
                    faseLic.EstadoFase = Valores.Codigo_Estado_Fase_Inicial;
                    faseLic.Save();
                }

            }
        }
        /// <summary>
        /// Finalizar creacion de expediente
        /// </summary>
        /// <param name="ifCompleto"></param>
        /// <returns></returns>
        private bool UpdateEstadoCreado(Boolean ifCompleto)
        {
            //CAMBIAR ESTADO INDICAR QUE SE HA COMPLETADO CREACION
            ExpedienteLicenciamiento objExpLic = ExpedienteLicenciamiento.GetEditableRoot(Guid.Parse(ExpedienteIdTmp));
            if (objExpLic.Estado == Valores.Codigo_Estado_Exp_Lic_Inicial)
            {
                objExpLic.Estado = Valores.Codigo_Estado_Exp_Lic_Creado;
                objExpLic.Save();
                ifCompleto = false;
            }
            return ifCompleto;
        }
        private void GenerarFormularios(CategoriaInformacionLista preguntas, int pi, int pf)
        {

            for (int i = pi; i < pf; i++)
            {
                var pregunta = preguntas[i];
                var fsGrupo = new FieldSet()
                {
                    ID = "fsGrupo" + pregunta.Id.ToString().Replace("-", ""),
                    Title = pregunta.SubCategoria,
                    Layout = "form",
                    Collapsible = true
                };
                if (pregunta.Tipo == Constantes.UNICA)
                {


                    foreach (var opcion in pregunta.Opciones)
                    {
                        var fcContenedor = new FieldContainer()
                        {
                            ID = "fcContenedor" + opcion.Id.ToString().Replace("-", ""),
                            AnchorHorizontal = "100%",
                            Layout = "HBoxLayout"
                        };
                        var radSeleccionU = new Radio()
                        {
                            ID = "radSeleccionU" + opcion.Id.ToString().Replace("-", ""),
                            BoxLabel = opcion.Nombre,
                            Name = pregunta.Id.ToString().Replace("-", ""),
                            LabelAlign = LabelAlign.Left
                        };
                        fcContenedor.Items.Add(radSeleccionU);
                        if (opcion.Opcion == Constantes.INPUTDATA)//Para cuando se trate de condición de que debe especificar un valor
                        {
                            var tfCampo = new TextField()
                            {
                                ID = "tfCampo" + opcion.Id.ToString().Replace("-", ""),
                                Hidden = true
                            };
                            fcContenedor.Items.Add(tfCampo);
                            radSeleccionU.Listeners.Change.Handler = string.Format("MostrarControl(item,newValue,oldValue,App.{0})", tfCampo.ID);
                        }


                        fsGrupo.Items.Add(fcContenedor);
                    }
                }
                else
                {
                    foreach (var opcion in pregunta.Opciones)
                    {
                        var fcContenedorM = new FieldContainer()
                        {
                            ID = "fcContenedor" + opcion.Id.ToString().Replace("-", ""),
                            AnchorHorizontal = "100%",
                            Layout = "HBoxLayout"
                        };
                        var radSeleccionM = new Ext.Net.Checkbox()
                        {
                            ID = "chkOM" + opcion.Id.ToString().Replace("-", ""),
                            BoxLabel = opcion.Nombre,
                            //Name = opcion.Nombre,
                            LabelAlign = LabelAlign.Left
                        };
                        //radSeleccionM.

                        if (opcion.Opcion == Constantes.INPUTDATA)//Para cuando se trate de condición de que debe especificar un valor
                        {
                            var tfCampo = new TextField()
                            {
                                ID = "tfCampo" + opcion.Id.ToString().Replace("-", ""),
                                Hidden = true
                            };
                            radSeleccionM.Listeners.Change.Handler = string.Format("MostrarControl(item,newValue,oldValue,App.{0});", tfCampo.ID);

                            fcContenedorM.Items.Add(radSeleccionM);
                            fcContenedorM.Items.Add(tfCampo);
                        }
                        else
                            fcContenedorM.Items.Add(radSeleccionM);
                        fsGrupo.Items.Add(fcContenedorM);
                    }
                }
                // frmD3.Items.Add(fsGrupo);
            }

        }
        private void GenerarFormularios(CategoriaInformacionLista preguntas)
        {
            var contrles = "";
            foreach (var pregunta in preguntas)
            {
                var fsGrupo = string.Format("<ext:FieldSet ID=\"fs_{1}\" runat=\"server\" Title=\"{2}\" Collapsible=\"True\" Layout=\"form\">{0}<Items>", Environment.NewLine, pregunta.Id.ToString().Replace("-", ""), pregunta.SubCategoria);
                //Falta especificar FieldLabel
                var numField = string.Format("<ext:NumberField ID=\"nuf_{0}\" Name=\"nf_{0}\" runat=\"server\" AllowBlank=\"false\"  Hidden=\"true\"  Text=\"0\" MinText=\"Se requiere que selecione al menus una opción\"  MinValue=\"1\"   FieldLabel=\"*{1}\"/>", pregunta.Codigo, pregunta.SubCategoria);
                fsGrupo += numField;
                if (pregunta.Tipo == Constantes.UNICA)
                {
                    foreach (var opcion in pregunta.Opciones)
                    {
                        var fcContenedor = string.Format("<ext:FieldContainer runat=\"server\" AnchorHorizontal=\"100%\" Layout=\"HBoxLayout\">{0}<Items>{0}", Environment.NewLine);
                        var radSeleccionU = string.Format("<ext:Radio ID=\"rb_{0}\" runat=\"server\" InputValue=\"{0}\" BoxLabel=\"{1}\" Name=\"{2}\" LabelAlign=\"Left\">", opcion.Codigo, opcion.Nombre, pregunta.Codigo);


                        if (opcion.Opcion == Constantes.INPUTDATA)
                        //Para cuando se trate de condición de que debe especificar un valor
                        {
                            //Falta especificar nf
                            radSeleccionU =
                                string.Format(
                                    "{0}{1}<Listeners>{1}<Change Handler=\"MostrarControlObligatorio(item,newValue,oldValue,App.txt_{2},App.nuf_{3});\"></Change>{1} </Listeners>{1}</ext:Radio>{1}",
                                    radSeleccionU, Environment.NewLine, opcion.Codigo, pregunta.Codigo);
                            var tfCampo =
                                string.Format(
                                    "{0}<ext:TextField ID=\"txt_{1}\" runat=\"server\" Hidden=\"True\"><Listeners><Change Handler=\"DatosOtros(item,newValue,oldValue);\"></Change></Listeners></ext:TextField>",
                                    Environment.NewLine, opcion.Codigo);
                            radSeleccionU = string.Format("{0}{1}", radSeleccionU, tfCampo);
                        }
                        else
                        {
                            var listenerRB = string.Format("{0}{1}<Listeners>{1}<Change Handler=\"SetNumberFieldControl(item,newValue,oldValue,App.nuf_{2});\"></Change>{1} </Listeners>{1}", "", Environment.NewLine, pregunta.Codigo);
                            radSeleccionU = string.Format("{0}{1}{2}{1}</ext:Radio>{1}", radSeleccionU, Environment.NewLine, listenerRB);
                        }
                        var campoLabel = "";
                        if (opcion.Nombre.Length < opcion.Descripcion.Length)
                        {
                            campoLabel = string.Format("<ext:Label ID=\"lb{0}\" runat=\"server\" Text=\"{1}\" Margins=\"3 0 0 15\"></ext:Label>", opcion.Id.ToString().Replace("-", ""), opcion.Descripcion);
                        }
                        fcContenedor = string.Format("{0}{1}{3}</Items>{2}</ext:FieldContainer>{2}", fcContenedor, radSeleccionU, Environment.NewLine, campoLabel);
                        fsGrupo = string.Format("{0}{1}", fsGrupo, fcContenedor);
                    }
                }
                else
                {
                    foreach (var opcion in pregunta.Opciones)
                    {
                        var fcContenedor = string.Format("<ext:FieldContainer runat=\"server\" AnchorHorizontal=\"100%\" Layout=\"HBoxLayout\">{0}<Items>{0}", Environment.NewLine);
                        var radSeleccionU = string.Format("<ext:Checkbox ID=\"ch_{0}\" Name=\"{0}\" runat=\"server\" BoxLabel=\"{1}\" LabelAlign=\"Left\">", opcion.Codigo, opcion.Nombre);


                        if (opcion.Opcion == Constantes.INPUTDATA)
                        //Para cuando se trate de condición de que debe especificar un valor
                        {
                            radSeleccionU =
                                string.Format(
                                    "{0}{1}<Listeners>{1}<Change Handler=\"MostrarControlObligatorio(item,newValue,oldValue,App.txt_{2},App.nuf_{3});\"></Change>{1} </Listeners>{1}</ext:Checkbox>{1}",
                                    radSeleccionU, Environment.NewLine, opcion.Codigo, pregunta.Codigo);
                            var tfCampo =
                                string.Format(
                                    "{0}<ext:TextField ID=\"txt_{1}\" runat=\"server\" Hidden=\"True\"><Listeners><Change Handler=\"DatosOtros(item,newValue,oldValue);\"></Change></Listeners></ext:TextField>",
                                    Environment.NewLine, opcion.Codigo);
                            radSeleccionU = string.Format("{0}{1}", radSeleccionU, tfCampo);
                        }
                        else
                        {
                            var listenerCB = string.Format("{0}{1}<Listeners>{1}<Change Handler=\"SetNumberFieldControl(item,newValue,oldValue,App.nuf_{2});\"></Change>{1} </Listeners>{1}", "", Environment.NewLine, pregunta.Codigo);
                            radSeleccionU = string.Format("{0}{1}{2}{1}</ext:Checkbox>{1}", radSeleccionU, Environment.NewLine, listenerCB);
                        }
                        var campoLabel = "";
                        if (opcion.Nombre.Length < opcion.Descripcion.Length)
                        {
                            campoLabel = string.Format("<ext:Label ID=\"lb{0}\" runat=\"server\" Text=\"{1}\" Margins=\"3 0 0 15\"></ext:Label>", opcion.Id.ToString().Replace("-", ""), opcion.Descripcion);
                        }
                        fcContenedor = string.Format("{0}{1}{3}</Items>{2}</ext:FieldContainer>{2}", fcContenedor, radSeleccionU, Environment.NewLine, campoLabel);
                        fsGrupo = string.Format("{0}{1}", fsGrupo, fcContenedor);
                    }

                }
                fsGrupo = string.Format("{0}</Items>{1}</ext:FieldSet>{1}", fsGrupo, Environment.NewLine);
                contrles = string.Format("{0}{1}", contrles, fsGrupo);
            }
            File.WriteAllText(MapPath("~/") + "/ct.text", contrles, Encoding.UTF8);
            //txaControles.SetValue(contrles);
        }
        #endregion
        protected void OnLoadDocAdded(object sender, ComponentAddedEventArgs e)
        {
            try
            {
                Ext.Net.Panel panel = (Ext.Net.Panel)e.Control;

                SetCustomConfigWucLicAll(panel, SessionPage.PageGestionExpLic, CodeFaseInicial);
            }
            catch (Exception ex)
            {
                RegistrarLog(ex);
            }

        }
    }
}